#include"server.hpp"


//写完channel和poller的一个联合测试

// void HandelClose(Channel *channel)
// {
//     std::cout<<"HandelClose/ERR: "<<channel->GetFd()<<std::endl;
//     channel->Remove();
//     delete channel;
    
// }
// void HandelRead(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     char buf[1024]={0};
//     int ret = recv(fd,buf,1023,0);
//     if(ret<=0)
//     {
//         return HandelClose(channel);
//     }
//     std::cout<<"HandelRead: "<<buf<<std::endl;
//     //读取数据后，给客户端返回信息
//     //启动写事件监控
//     channel->EnableWrite();//即添加写监控
// }
// void HandelWrite(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     const char *data="HandelWrite:您吃了吗？";
//     int ret = send(fd,data,strlen(data),0);
//     if(ret < 0)
//     {
//         return HandelClose(channel);
//     }
//     //写完，发送完数据后，没什么可干了，关闭写监控,也就是取消写事件的监控
//     channel->DisableWrite();
// }

// void HandelErr(Channel *channel)
// {
//     return HandelClose(channel);
// }
// void HandelEvent(Channel *channel)
// {
//     std::cout<<"HandelEvent: 有一个事件！"<<std::endl;
// }

// void Accepter(Poller* poller,Channel* lis_channel)
// {
//     //获取用于通信的套接字，并为该套接字创建Channel管理起来
//     int fd = lis_channel->GetFd();//监听套接字
//     int newfd = accept(fd,NULL,NULL);
//     if(newfd < 0) return;
//     Channel *channel = new Channel(poller,newfd);//这里需要new出来，因为这个channel不能随着Accepter的销毁而销毁！
//     //为该通信套接字的channel设置各种回调函数，进行事件监控和事件处理
//     channel->SetReadCallback(std::bind(HandelRead,channel));
//     channel->SetWriteCallback(std::bind(HandelWrite,channel));
//     channel->SetErrorCallback(std::bind(HandelErr,channel));
//     channel->SetCloseCallback(std::bind(HandelClose,channel));
//     channel->SetEventCallback(std::bind(HandelEvent,channel));
//     channel->EnableRead();//启动读事件监控
// }
// int main()
// {
//     Poller poller;
//     Socket lis_sock;
//     lis_sock.CreateServer(8500);
//     //为监听套接字创建一个Channel进行事件管理以及事件处理
//     Channel channel(&poller,lis_sock.GetFd());
//     //设置监听套接字的可读回调函数
//     channel.SetReadCallback(std::bind(Accepter,&poller,&channel));
//     channel.EnableRead();//启动读事件监控,挂到红黑树上进行监控---一旦事件就绪，即客户端有新连接到来，即可进行通信
//     //进入循环，获取活跃连接，即事件就绪的连接，与客户端进行通信
//     while(1)
//     {
//         std::vector<Channel*> actives;
//         poller.Poll(&actives);
//         for(auto& f:actives)
//         {
//             f->HandleEvent();//进行事件处理   
//         }
//     }
//     lis_sock.Close();
//     return 0;
// }


//写完Eventloop后的一个测试
// void HandelClose(Channel *channel)
// {
//     std::cout<<"HandelClose/ERR: "<<channel->GetFd()<<std::endl;
//     channel->Remove();
//     delete channel;
    
// }
// void HandelRead(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     char buf[1024]={0};
//     int ret = recv(fd,buf,1023,0);
//     if(ret<=0)
//     {
//         return HandelClose(channel);
//     }
//     std::cout<<"HandelRead: "<<buf<<std::endl;
//     //读取数据后，给客户端返回信息
//     //启动写事件监控
//     channel->EnableWrite();//即添加写监控
// }
// void HandelWrite(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     const char *data="HandelWrite:您吃了吗？";
//     int ret = send(fd,data,strlen(data),0);
//     if(ret < 0)
//     {
//         return HandelClose(channel);
//     }
//     //写完，发送完数据后，没什么可干了，关闭写监控,也就是取消写事件的监控
//     channel->DisableWrite();
// }

// void HandelErr(Channel *channel)
// {
//     return HandelClose(channel);
// }
// void HandelEvent(Channel *channel)
// {
//     std::cout<<"HandelEvent: 有一个事件！"<<std::endl;
// }

// void Accepter(EventLoop* loop,Channel* lis_channel)
// {
//     //获取用于通信的套接字，并为该套接字创建Channel管理起来
//     int fd = lis_channel->GetFd();//监听套接字
//     int newfd = accept(fd,NULL,NULL);
//     if(newfd < 0) return;
//     Channel *channel = new Channel(loop,newfd);//这里需要new出来，因为这个channel不能随着Accepter的销毁而销毁！
//     //为该通信套接字的channel设置各种回调函数，进行事件监控和事件处理
//     channel->SetReadCallback(std::bind(HandelRead,channel));
//     channel->SetWriteCallback(std::bind(HandelWrite,channel));
//     channel->SetErrorCallback(std::bind(HandelErr,channel));
//     channel->SetCloseCallback(std::bind(HandelClose,channel));
//     channel->SetEventCallback(std::bind(HandelEvent,channel));
//     channel->EnableRead();//启动读事件监控

//     //非活跃连接的超时释放操作

// }
// int main()
// {
//     EventLoop loop;
//     Socket lis_sock;
//     lis_sock.CreateServer(8500);
//     //为监听套接字创建一个Channel进行事件管理以及事件处理
//     Channel channel(&loop,lis_sock.GetFd());
//     //设置监听套接字的可读回调函数
//     channel.SetReadCallback(std::bind(Accepter,&loop,&channel));
//     channel.EnableRead();//启动读事件监控,挂到红黑树上进行监控---一旦事件就绪，即客户端有新连接到来，即可进行通信
//     //进入循环，获取活跃连接，即事件就绪的连接，与客户端进行通信
//     while(1)
//     {
//         loop.Start();
//     }
//     lis_sock.Close();
//     return 0;
// }

//eventloop、timewheel联合调试
// void HandelClose(Channel *channel)
// {
//     DBG_LOG("close fd:%d",channel->GetFd());
//     channel->Remove();
//     delete channel;
    
// }
// void HandelRead(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     char buf[1024]={0};
//     int ret = recv(fd,buf,1023,0);
//     if(ret<=0)
//     {
//         return HandelClose(channel);
//     }
//     DBG_LOG("%s",buf);
//     //读取数据后，给客户端返回信息
//     //启动写事件监控
//     channel->EnableWrite();//即添加写监控
// }
// void HandelWrite(Channel *channel)
// {
//     int fd = channel->GetFd();//获取通信套接字
//     const char *data="HandelWrite:您吃了吗？";
//     int ret = send(fd,data,strlen(data),0);
//     if(ret < 0)
//     {
//         return HandelClose(channel);
//     }
//     //写完，发送完数据后，没什么可干了，关闭写监控,也就是取消写事件的监控
//     channel->DisableWrite();
// }

// void HandelErr(Channel *channel)
// {
//     return HandelClose(channel);
// }
// void HandelEvent(EventLoop *loop,Channel *channel,uint64_t timerid)
// {
//     loop->TimerRefresh(timerid);
// }

// void Accepter(EventLoop* loop,Channel* lis_channel)
// {
//     //获取用于通信的套接字，并为该套接字创建Channel管理起来
//     int fd = lis_channel->GetFd();//监听套接字
//     int newfd = accept(fd,NULL,NULL);
//     if(newfd < 0) return;
//     uint64_t timerid = rand() % 10000;
//     Channel *channel = new Channel(loop,newfd);//这里需要new出来，因为这个channel不能随着Accepter的销毁而销毁！
//     //为该通信套接字的channel设置各种回调函数，进行事件监控和事件处理
//     channel->SetReadCallback(std::bind(HandelRead,channel));
//     channel->SetWriteCallback(std::bind(HandelWrite,channel));
//     channel->SetErrorCallback(std::bind(HandelErr,channel));
//     channel->SetCloseCallback(std::bind(HandelClose,channel));
//     channel->SetEventCallback(std::bind(HandelEvent,loop,channel,timerid));
//     //非活跃连接的超时释放操作,10s后关闭连接
//     //定时销毁任务必须在启动读事件监控之前
//     //因为有可能启动了读事件监控后，立即有了事件，但是这时候还没有任务
//     loop->TimerAdd(timerid,10,std::bind(HandelClose,channel));
//     channel->EnableRead();//启动读事件监控

// }
// int main()
// {
//     srand(time(NULL));
//     EventLoop loop;
//     Socket lis_sock;
//     lis_sock.CreateServer(8500);
//     //为监听套接字创建一个Channel进行事件管理以及事件处理
//     Channel channel(&loop,lis_sock.GetFd());
//     //设置监听套接字的可读回调函数
//     channel.SetReadCallback(std::bind(Accepter,&loop,&channel));
//     channel.EnableRead();//启动读事件监控,挂到红黑树上进行监控---一旦事件就绪，即客户端有新连接到来，即可进行通信
//     //进入循环，获取活跃连接，即事件就绪的连接，与客户端进行通信
//     while(1)
//     {
//         loop.Start();
//     }
//     lis_sock.Close();
//     return 0;
// }


//Connection模块调试
// std::unordered_map<uint64_t,PtrConnection> _conns;//管理所有的连接
// uint64_t conn_id = 0;

// void ConnectionDestory(const PtrConnection &conn)
// {
//     _conns.erase(conn->GetConnId());
// }

// void OnConnected(const PtrConnection &conn)
// {
//     DBG_LOG("OnConnected %p",conn.get());
// }

// void OnMessage(const PtrConnection &conn,Buffer *buf)
// {
//     DBG_LOG("%s",buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str="OnMessage hello world!";
//     conn->Send(str.c_str(),str.size());
// }

// void OnEvent(const PtrConnection &conn)
// {

// }
// void Accepter(EventLoop* loop,Channel* lis_channel)
// {
//     //获取用于通信的套接字，并为该套接字创建Channel管理起来
//     int fd = lis_channel->GetFd();//监听套接字
//     int newfd = accept(fd,NULL,NULL);
//     if(newfd < 0) return;
//     conn_id++;
//     PtrConnection conn(new Connection(loop,conn_id,newfd));
//     conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     conn->SetMessageCallBack(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     conn->SetSrvCloseCallBack(std::bind(ConnectionDestory,std::placeholders::_1));
//     conn->SetEventCallBack(std::bind(OnEvent,std::placeholders::_1));
//     //启动非活跃销毁
//     conn->EnableInactiveRelease(10);
//     //就绪初始化
//     conn->Establish();
//     _conns.insert(std::make_pair(conn_id,conn));
// }
// int main()
// {
//     srand(time(NULL));
//     EventLoop loop;
//     Socket lis_sock;
//     lis_sock.CreateServer(8500);
//     //为监听套接字创建一个Channel进行事件管理以及事件处理
//     Channel channel(&loop,lis_sock.GetFd());
//     //设置监听套接字的可读回调函数
//     channel.SetReadCallback(std::bind(Accepter,&loop,&channel));
//     channel.EnableRead();//启动读事件监控,挂到红黑树上进行监控---一旦事件就绪，即客户端有新连接到来，即可进行通信
//     //进入循环，获取活跃连接，即事件就绪的连接，与客户端进行通信
//     while(1)
//     {
//         loop.Start();
//     }
//     lis_sock.Close();
//     return 0;
// }


//Acceptor模块调试
// std::unordered_map<uint64_t,PtrConnection> _conns;//管理所有的连接
// uint64_t conn_id = 0;
// EventLoop loop;
// void ConnectionDestory(const PtrConnection &conn)
// {
//     _conns.erase(conn->GetConnId());
// }

// void OnConnected(const PtrConnection &conn)
// {
//     DBG_LOG("OnConnected %p",conn.get());
// }

// void OnMessage(const PtrConnection &conn,Buffer *buf)
// {
//     DBG_LOG("%s",buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str="OnMessage hello world!";
//     conn->Send(str.c_str(),str.size());
// }

// void OnEvent(const PtrConnection &conn)
// {

// }
// void NewConnection(int fd)
// {
//     conn_id++;
//     PtrConnection conn(new Connection(&loop,conn_id,fd));
//     conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     conn->SetMessageCallBack(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     conn->SetSrvCloseCallBack(std::bind(ConnectionDestory,std::placeholders::_1));
//     conn->SetEventCallBack(std::bind(OnEvent,std::placeholders::_1));
//     //启动非活跃销毁
//     conn->EnableInactiveRelease(10);
//     //就绪初始化
//     conn->Establish();
//     _conns.insert(std::make_pair(conn_id,conn));
// }
// int main()
// {
//     srand(time(NULL));
//     Acceptor acceptor(&loop,8500);
//     //设置监听套接字的可读回调函数
//     acceptor.SetAcceptCallBack(std::bind(NewConnection,std::placeholders::_1));
//     acceptor.Listen();
//     while(1)
//     {
//         loop.Start();
//     }
//     return 0;
// }


//LoopThread模块调试
// std::unordered_map<uint64_t,PtrConnection> _conns;//管理所有的连接
// uint64_t conn_id = 0;
// std::vector<LoopThread> threads(2);
// int next_loop = 0;
// EventLoop base_loop;//主线程的loop
// void ConnectionDestory(const PtrConnection &conn)
// {
//     _conns.erase(conn->GetConnId());
// }

// void OnConnected(const PtrConnection &conn)
// {
//     DBG_LOG("OnConnected %p",conn.get());
// }

// void OnMessage(const PtrConnection &conn,Buffer *buf)
// {
//     DBG_LOG("%s",buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str="OnMessage hello world!";
//     conn->Send(str.c_str(),str.size());
// }

// void OnEvent(const PtrConnection &conn)
// {

// }
// void NewConnection(int fd)
// {
//     conn_id++;
//     next_loop = (next_loop+1)%2;
//     PtrConnection conn(new Connection(threads[next_loop].GetLoop(),conn_id,fd));
//     conn->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1));
//     conn->SetMessageCallBack(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     conn->SetSrvCloseCallBack(std::bind(ConnectionDestory,std::placeholders::_1));
//     conn->SetEventCallBack(std::bind(OnEvent,std::placeholders::_1));
//     //启动非活跃销毁
//     conn->EnableInactiveRelease(10);
//     //就绪初始化
//     conn->Establish();
//     _conns.insert(std::make_pair(conn_id,conn));
// }
// int main()
// {
//     srand(time(NULL));
//     Acceptor acceptor(&base_loop,8500);
//     //设置监听套接字的可读回调函数
//     acceptor.SetAcceptCallBack(std::bind(NewConnection,std::placeholders::_1));
//     acceptor.Listen();
//     while(1)
//     {
//         base_loop.Start();
//     }
//     return 0;
// }


//LoopThreadPoll模块调试
// std::unordered_map<uint64_t,PtrConnection> _conns;//管理所有的连接
// uint64_t conn_id = 0;
// EventLoop base_loop;//主线程的loop
// LoopThreadPool *loop_pool;
// void ConnectionDestory(const PtrConnection &conn)
// {
//     _conns.erase(conn->GetConnId());
// }

// void OnConnected(const PtrConnection &conn)
// {
//     DBG_LOG("OnConnected %p",conn.get());
// }

// void OnMessage(const PtrConnection &conn,Buffer *buf)
// {
//     DBG_LOG("%s",buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str="OnMessage hello world!";
//     conn->Send(str.c_str(),str.size());
// }

// void OnEvent(const PtrConnection &conn)
// {

// }
// void NewConnection(int fd)
// {
//     conn_id++;
//     PtrConnection conn(new Connection(loop_pool->NextLoop(),conn_id,fd));
//     conn->SetConnectedCallBack(std::bind(OnConnected,std::placeholders::_1));
//     conn->SetMessageCallBack(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2));
//     conn->SetSrvCloseCallBack(std::bind(ConnectionDestory,std::placeholders::_1));
//     conn->SetEventCallBack(std::bind(OnEvent,std::placeholders::_1));
//     //启动非活跃销毁
//     conn->EnableInactiveRelease(10);
//     //就绪初始化
//     conn->Establish();
//     _conns.insert(std::make_pair(conn_id,conn));
// }
// int main()
// {
//     loop_pool = new LoopThreadPool(&base_loop);
//     loop_pool->SetThreadCount(2);
//     loop_pool->Create();
//     Acceptor acceptor(&base_loop,8500);
//     //设置监听套接字的可读回调函数
//     acceptor.SetAcceptCallBack(std::bind(NewConnection,std::placeholders::_1));
//     acceptor.Listen();
//     base_loop.Start();
    
//     return 0;
// }

//TCPServer模块
void OnConnected(const PtrConnection &conn)
{
    DBG_LOG("OnConnected %p",conn.get());
}
void OnClosed(const PtrConnection &conn)
{
    DBG_LOG("CLOSE CONNECTION %p",conn.get());
}

void OnMessage(const PtrConnection &conn,Buffer *buf)
{
    DBG_LOG("%s",buf->ReadPosition());
    buf->MoveReadOffset(buf->ReadAbleSize());
    std::string str="OnMessage hello world!";
    conn->Send(str.c_str(),str.size());
}

int main()
{

    TCPServer server(8500);//服务器对象
    server.SetThreadCount(5);//从属线程个数为5
    server.EnableInactiveRelease(10);//非活跃超时时间：10秒
    server.SetCloseCallBack(OnClosed);
    server.SetConnectedCallBack(OnConnected);
    server.SetMessageCallBack(OnMessage);
    server.Start();
    return 0;
}
